package juc.cas.source;

/**
 * @ClassName LongAdderSoure
 * @PackageName juc.cas.source
 * @projectName myThread
 * @Description 
 * @Author games
 * @Date 2025/9/1 上午10:23
 * @Version 1.0
 */
public class LongAdderSoure {

    /**
     * 向当前值添加指定的值x。
     * 这是一个原子操作，适用于高并发场景下的计数或累加操作。
     * 该方法首先尝试直接更新base字段，如果存在竞争则使用Cell数组进行分散更新。
     *
     * @param x 要添加的值
     */
    //public void add(long x) {
    //    Cell[] cs; long b, v; int m; Cell c;
    //    // 首先尝试直接更新base字段，如果cells数组不为空或者更新base失败(说明存在竞争)
    //    if ((cs = cells) != null || !casBase(b = base, b + x)) {
    //        // 获取当前线程的probe值作为hash值
    //        int index = getProbe();
    //        // 标记此次更新是否无竞争
    //        boolean uncontended = true;
    //        // 检查是否需要进行分散更新
    //        // 条件包括：cells数组为空、数组长度小于等于0、对应位置的Cell为空、CAS更新Cell失败
    //        if (cs == null || (m = cs.length - 1) < 0 ||
    //                (c = cs[index & m]) == null ||
    //                !(uncontended = c.cas(v = c.value, v + x)))
    //            // 调用longAccumulate方法处理竞争情况
    //            longAccumulate(x, null, uncontended, index);
    //    }
    //}

    /**
     * 当直接更新base失败或cells数组不为空时，使用此方法进行值的累加操作。
     * 该方法通过线程探测索引将值放入Cell数组中，以减少竞争并提高并发性能。
     * 如果对应的Cell不存在，则尝试创建新的Cell；如果存在竞争，则尝试扩容cells数组。
     * 最终如果所有尝试都失败，则回退到更新base字段。
     *
     * 按位与运算符
     * 这种技术通常用于实现循环数组或环形缓冲区，以高效地利用数组空间。
     * n = 5
     * index = 0b111  # 二进制表示为111，十进制为7
     * index_in_array = (n - 1) & index
     * print(index_in_array)  # 输出: 4
     *
     *
     * 左移操作（n << 1）
     *左移操作：在二进制运算中，左移操作（<<）是将一个数的二进制表示向左移动指定的位数。每向左移动一位，相当于该数乘以2。
     * int n = 3;
     * int newSize = n << 1;  // 新大小为6
     * int[] oldArray = {1, 2, 3}
     *
     * @param x 要累加的值
     * @param fn 用于计算新值的二元操作函数，如果为null则直接进行加法操作
     * @param wasUncontended 指示上一次CAS操作是否无竞争
     * @param index 线程探测索引值，用于计算Cell数组中的位置
     */
    //final void longAccumulate(long x, LongBinaryOperator fn,
    //                          boolean wasUncontended, int index) {
    //    // 如果index为0，说明线程probe值未初始化，需要强制初始化
    //    if (index == 0) {
    //        ThreadLocalRandom.current(); // force initialization
    //        index = getProbe();
    //        wasUncontended = true;
    //    }
    //
    //    // 无限循环，直到成功更新值为止
    //    for (boolean collide = false;;) {       // True if last slot nonempty
    //        Striped64.Cell[] cs; Striped64.Cell c; int n; long v;
    //
    //        // 检查cells数组是否已初始化且长度大于0
    //        if ((cs = cells) != null && (n = cs.length) > 0) {
    //            // 检查对应位置的Cell是否为空
    //            if ((c = cs[(n - 1) & index]) == null) {
    //                // 尝试创建新的Cell并添加到数组中
    //                if (cellsBusy == 0) {       // Try to attach new Cell
    //                    Striped64.Cell r = new Striped64.Cell(x);   // Optimistically create
    //                    if (cellsBusy == 0 && casCellsBusy()) {
    //                        try {               // Recheck under lock
    //                            Striped64.Cell[] rs; int m, j;
    //                            if ((rs = cells) != null &&
    //                                    (m = rs.length) > 0 &&
    //                                    rs[j = (m - 1) & index] == null) {
    //                                rs[j] = r;
    //                                break;
    //                            }
    //                        } finally {
    //                            cellsBusy = 0;
    //                        }
    //                        continue;           // Slot is now non-empty
    //                    }
    //                }
    //                collide = false;
    //            }
    //            // 如果上一次CAS操作已知会失败，则重新标记为无竞争并继续
    //            else if (!wasUncontended)       // CAS already known to fail
    //                wasUncontended = true;      // Continue after rehash
    //            // 尝试对Cell进行CAS更新
    //            else if (c.cas(v = c.value,
    //                    (fn == null) ? v + x : fn.applyAsLong(v, x)))
    //                break;
    //            // 检查是否达到最大容量或cells数组已过期
    //            else if (n >= NCPU || cells != cs)
    //                collide = false;            // At max size or stale
    //            // 如果还未标记为冲突，则标记为冲突
    //            else if (!collide)
    //                collide = true;
    //            // 尝试扩容cells数组
    //            else if (cellsBusy == 0 && casCellsBusy()) {
    //                try {
    //                    if (cells == cs)        // Expand table unless stale
    //                        cells = Arrays.copyOf(cs, n << 1);
    //                } finally {
    //                    cellsBusy = 0;
    //                }
    //                collide = false;
    //                continue;                   // Retry with expanded table
    //            }
    //            // 更新线程探测索引值
    //            index = advanceProbe(index);
    //        }
    //        // 尝试初始化cells数组
    //        else if (cellsBusy == 0 && cells == cs && casCellsBusy()) {
    //            try {                           // Initialize table
    //                if (cells == cs) {
    //                    Striped64.Cell[] rs = new Striped64.Cell[2];
    //                    rs[index & 1] = new Striped64.Cell(x);
    //                    cells = rs;
    //                    break;
    //                }
    //            } finally {
    //                cellsBusy = 0;
    //            }
    //        }
    //        // 最后回退到更新base字段
    //        // Fall back on using base
    //        else if (casBase(v = base,
    //                (fn == null) ? v + x : fn.applyAsLong(v, x)))
    //            break;
    //    }
    //}
}
